// course-detail.js
// 获取应用实例
const app = getApp()
const playRecordUtil = require('../../utils/playRecordUtil.js')
const collectionUtil = require('../../utils/collectionUtil.js')
const vipUtil = require('../../utils/vipUtil.js')

Page({
  data: {
    course: {},
    chapters: [],
    lecturer: {},
    currentChapter: 1,
    isCollected: false,
    userId: 1, // 默认用户ID
    currentProgress: 0, // 当前播放进度（秒）
    videoContext: null,
    // AI分析相关
    showAIAnalysis: false,
    aiAnalysisData: null,
    isAIAnalyzing: false,
    showAIOptions: false,
    selectedAnalysisType: null,
    // 小圆球位置
    ballPosition: {
      x: 0,
      y: 0
    },
    // 触摸相关
    ballTouchStart: {
      x: 0,
      y: 0
    },
    isDragging: false
  },

  playRecordManager: null, // 播放记录管理器

  onLoad(options) {
    const courseId = options.id
    console.log('页面加载，课程ID:', courseId, '类型:', typeof courseId)
    
    // 获取用户ID
    const userInfo = wx.getStorageSync('userInfo')
    if (userInfo && userInfo.id) {
      this.setData({ userId: userInfo.id })
    }
    
    // 设置网络状态监听
    this.setupNetworkMonitoring()
    
    // 静默测试播放记录API连接，失败时直接使用离线模式
    playRecordUtil.testPlayRecordAPI()
      .then(() => {
        console.log('播放记录API连接正常')
        // 尝试同步离线记录
        this.syncOfflineRecords()
      })
      .catch(err => {
        // 静默处理API连接失败，不显示日志
        // API连接失败时，尝试同步离线记录
        this.syncOfflineRecords()
      })
    
    this.loadCourseDetail(courseId)
  },

  onReady() {
    // 创建视频上下文
    this.videoContext = wx.createVideoContext('courseVideo', this)
    
    // 初始化小圆球位置
    this.initBallPosition()
  },

  onShow() {
    // 页面显示时恢复播放进度
    if (this.data.course.id && this.data.chapters.length > 0) {
      this.restorePlayProgress(this.data.course.id, this.data.chapters[0].id)
    }
    
    // 检查是否有待播放的章节（用户登录后返回）
    this.checkPendingChapter()
  },

  // 加载课程详情
  loadCourseDetail(courseId) {
    // 从API获取课程详情数据
    this.getCourseDetail(courseId)
  },

  // 获取课程详情数据
  getCourseDetail(courseId) {
    wx.request({
      url: `http://localhost:8081/contentChapter/getCont`,
      method: 'GET',
      success: (res) => {
        console.log('API响应状态:', res.statusCode)
        console.log('课程详情数据:', res.data)
        
        if (res.statusCode === 200 && res.data) {
          // 确保res.data是数组
          const courseList = Array.isArray(res.data) ? res.data : [res.data]
          console.log('处理后的课程列表:', courseList)
          
          if (courseList.length > 0) {
            // 找到对应的课程 - 确保类型匹配
            const courseData = courseList.find(course => course.id == courseId || course.id === parseInt(courseId))
            console.log('查找课程ID:', courseId, '类型:', typeof courseId)
            console.log('可用课程ID列表:', courseList.map(c => ({ id: c.id, type: typeof c.id })))
            console.log('找到的课程:', courseData)
            
            if (courseData) {
              this.processCourseData(courseData)
            } else {
              console.log('未找到课程ID:', courseId, '可用课程ID:', courseList.map(c => c.id))
              wx.showToast({
                title: '课程不存在',
                icon: 'none'
              })
            }
          } else {
            console.log('API返回数据为空')
            wx.showToast({
              title: '课程数据为空',
              icon: 'none'
            })
          }
        } else {
          console.log('API请求失败，状态码:', res.statusCode)
          wx.showToast({
            title: '获取课程数据失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('获取课程详情失败:', err)
        wx.showToast({
          title: '获取课程详情失败',
          icon: 'none'
        })
      }
    })
  },

  // 处理课程数据
  processCourseData(courseData) {
    // 转换课程基本信息
    const course = {
      id: courseData.id,
      title: courseData.title,
      cover: courseData.cover,
      posterUrl: this.getPosterUrl(courseData.cover),
      videoUrl: courseData.chapterList && courseData.chapterList.length > 0 
        ? this.getVideoUrl(courseData.chapterList[0].videoUrl) 
        : '',
      type: courseData.type,
      typeText: courseData.type === 'course' ? '课程' : '其他',
      duration: courseData.duration,
      isFree: courseData.isFree === 1,
      isVipOnly: courseData.price > 0, // 价格大于0的课程需要VIP
      price: 0, // 不再显示价格，改为VIP限制
      viewCount: courseData.viewCount,
      saleCount: courseData.saleCount,
      intro: courseData.intro
    }
    
    console.log('课程数据处理完成:', {
      title: course.title,
      isFree: course.isFree,
      isVipOnly: course.isVipOnly,
      originalPrice: courseData.price
    })

    // 转换章节数据
    const chapters = courseData.chapterList ? courseData.chapterList.map(chapter => ({
      id: chapter.id,
      title: chapter.title,
      duration: chapter.duration,
      isFree: chapter.isFree === 1,
      isVipOnly: chapter.isFree !== 1, // 非免费的章节需要VIP
      videoUrl: this.getVideoUrl(chapter.videoUrl)
    })) : []

    // 转换讲师信息
    const lecturer = courseData.lecturer ? {
      name: courseData.lecturer.name,
      title: courseData.lecturer.title,
      avatar: this.getAvatarUrl(courseData.lecturer.avatar),
      intro: courseData.lecturer.intro
    } : {
      name: '未知讲师',
      title: '讲师',
      avatar: 'https://images.unsplash.com/photo-1612349317150-e413f6a5b16d?w=200&h=200&fit=crop&crop=face',
      intro: '暂无介绍'
    }

    this.setData({
      course,
      chapters,
      lecturer
    })

    // 检查收藏状态
    this.checkCollectionStatus(course.id)

    // 恢复播放进度
    if (chapters.length > 0) {
      this.restorePlayProgress(course.id, chapters[0].id)
    }
  },

  // 检查收藏状态
  async checkCollectionStatus(courseId) {
    const userId = this.data.userId || 2
    
    try {
      const isCollected = await collectionUtil.checkCollectionStatus(userId, 'content', courseId)
      this.setData({
        isCollected: isCollected
      })
    } catch (error) {
      console.error('检查收藏状态失败:', error)
      // 失败时默认为未收藏
      this.setData({
        isCollected: false
      })
    }
  },

  /**
   * 恢复播放进度
   */
  async restorePlayProgress(contentId, chapterId) {
    try {
      const record = await playRecordUtil.getPlayRecordByChapter(
        this.data.userId,
        chapterId
      )

      if (record && record.progress > 0) {
        console.log('找到播放记录，进度:', record.progress, '秒')
        
        wx.showToast({
          title: `继续上次播放 ${Math.floor(record.progress / 60)}分${record.progress % 60}秒`,
          icon: 'none',
          duration: 2000
        })

        // 延迟跳转到播放位置
        setTimeout(() => {
          if (this.videoContext) {
            this.videoContext.seek(record.progress)
          }
        }, 1500)
      }
    } catch (err) {
      console.error('恢复播放进度失败:', err)
    }
  },

  // 章节点击事件
  onChapterTap(e) {
    const chapterId = e.currentTarget.dataset.id
    const chapters = this.data.chapters
    const currentChapter = chapters.find(chapter => chapter.id == chapterId)
    
    if (currentChapter) {
      // 检查是否为VIP专享章节
      if (currentChapter.isVipOnly) {
        // 检查用户是否为VIP
        this.checkVipStatus(currentChapter)
        return
      }
      
      // 更新当前章节
      this.setData({
        currentChapter: chapterId
      })
      
      // 更新视频源
      this.setData({
        'course.videoUrl': this.getVideoUrl(currentChapter.videoUrl)
      })
      
      // 停止当前的播放记录管理器
      if (this.playRecordManager) {
        this.playRecordManager.stop(this.data.currentProgress)
        this.playRecordManager = null
      }

      // 重置当前进度
      this.setData({
        currentProgress: 0
      })

      // 重新加载视频
      const videoContext = wx.createVideoContext('courseVideo', this)
      if (videoContext) {
        videoContext.stop()
        setTimeout(() => {
          videoContext.play()
        }, 100)
      }
      
      console.log('切换到章节:', currentChapter.title, '视频:', currentChapter.videoUrl)
      
      // 尝试恢复该章节的播放进度
      this.restorePlayProgress(this.data.course.id, chapterId)
    }
  },

  // 显示VIP提示弹窗
  showVipModal(chapter) {
    wx.showModal({
      title: 'VIP专享内容',
      content: `章节"${chapter.title}"为VIP专享内容，需要开通VIP后才能观看。是否立即开通VIP？`,
      confirmText: '开通VIP',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          this.goToVipPurchase()
        }
      }
    })
  },

  // 收藏/取消收藏
  onCollect() {
    const isCollected = !this.data.isCollected
    const courseId = this.data.course.id
    
    if (isCollected) {
      // 添加收藏
      this.addCollection(courseId)
    } else {
      // 取消收藏
      this.removeCollection(courseId)
    }
  },

  // 添加收藏
  async addCollection(courseId) {
    const userId = 2 // 实际应该从用户信息获取
    
    try {
      const result = await collectionUtil.addCollection(userId, 'content', courseId)
      if (result.success) {
        this.setData({
          isCollected: true
        })
        collectionUtil.showResult(result, '收藏成功')
      } else {
        collectionUtil.showResult(result, '收藏成功', '收藏失败')
      }
    } catch (error) {
      console.error('收藏失败:', error)
      collectionUtil.showResult(error, '收藏成功', '收藏失败')
    }
  },

  // 取消收藏
  async removeCollection(courseId) {
    const userId = 2 // 实际应该从用户信息获取
    
    try {
      const result = await collectionUtil.removeCollection(userId, 'content', courseId)
      if (result.success) {
        this.setData({
          isCollected: false
        })
        collectionUtil.showResult(result, '取消收藏')
      } else {
        collectionUtil.showResult(result, '取消收藏', '取消收藏失败')
      }
    } catch (error) {
      console.error('取消收藏失败:', error)
      collectionUtil.showResult(error, '取消收藏', '取消收藏失败')
    }
  },

  // 检查VIP状态
  checkVipStatus(chapter) {
    console.log('检查VIP状态:', {
      chapterTitle: chapter.title,
      isVipOnly: chapter.isVipOnly
    })
    
    // 使用VIP工具类处理访问权限
    vipUtil.handleVipVideoAccess(
      chapter,
      (chapter) => {
        // 可以访问，播放章节
        console.log('可以观看章节:', chapter.title)
        this.playChapter(chapter)
      },
      (result) => {
        // 不能访问，显示相应提示
        console.log('不能观看章节:', result.message)
      }
    )
  },


  // 检查待播放的章节
  checkPendingChapter() {
    vipUtil.checkPendingChapter(
      this.data.course.id,
      this.data.chapters,
      (chapter) => {
        console.log('用户登录后返回，尝试播放章节:', chapter.title)
        this.checkVipStatus(chapter)
      }
    )
  },

  // 播放章节
  playChapter(chapter) {
    // 更新当前章节
    this.setData({
      currentChapter: chapter.id
    })
    
    // 更新视频源
    this.setData({
      'course.videoUrl': this.getVideoUrl(chapter.videoUrl)
    })
    
    // 重新加载视频
    const videoContext = wx.createVideoContext('courseVideo', this)
    videoContext.stop()
    videoContext.play()
    
    console.log('切换到章节:', chapter.title, '视频:', chapter.videoUrl)
  },

  // 跳转到VIP购买页面
  goToVipPurchase() {
    console.log('点击开通VIP按钮')
    wx.switchTab({
      url: '/pages/user/user',
      success: () => {
        console.log('跳转到用户页面成功')
      },
      fail: (err) => {
        console.error('跳转失败:', err)
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        })
      }
    })
  },

  // 开始学习
  onStart() {
    wx.showToast({
      title: '开始学习',
      icon: 'success'
    })
  },

  // 视频播放事件
  onVideoPlay(e) {
    console.log('🎬 视频开始播放')
    console.log('👤 当前用户ID:', this.data.userId)
    console.log('📚 当前课程ID:', this.data.course.id)
    console.log('📖 当前章节ID:', this.data.currentChapter)
    console.log('📊 课程数据:', this.data.course)
    
    // 启动播放记录自动保存
    if (this.data.course.id && this.data.currentChapter && this.data.userId) {
      // 停止之前的管理器（如果有）
      if (this.playRecordManager) {
        this.playRecordManager.stop()
      }

      console.log('🔄 创建播放记录管理器...')
      
      // 获取当前章节信息
      const currentChapterInfo = this.data.chapters.find(chapter => chapter.id === this.data.currentChapter) || {}
      
      // 创建新的播放记录管理器
      this.playRecordManager = playRecordUtil.createPlayRecordManager({
        userId: this.data.userId,
        contentId: this.data.course.id,
        chapterId: this.data.currentChapter,
        courseInfo: this.data.course,
        chapterInfo: currentChapterInfo,
        saveInterval: 10000 // 每10秒保存一次
      })

      // 开始自动保存
      this.playRecordManager.start(() => {
        const progress = this.data.currentProgress
        console.log('⏱️ 获取播放进度:', progress, '秒')
        return progress
      })

      console.log('✅ 播放记录自动保存已启动')
    } else {
      console.error('❌ 播放记录启动失败：缺少必要参数', {
        userId: this.data.userId,
        courseId: this.data.course.id,
        chapterId: this.data.currentChapter,
        hasUserId: !!this.data.userId,
        hasCourseId: !!this.data.course.id,
        hasChapterId: !!this.data.currentChapter
      })
    }
  },

  // 视频暂停事件
  onVideoPause(e) {
    console.log('视频暂停，当前进度:', this.data.currentProgress, '秒')
    
    // 立即保存当前进度
    if (this.playRecordManager && this.data.currentProgress > 0) {
      this.playRecordManager.saveNow(this.data.currentProgress)
        .then(() => {
          console.log('播放进度已保存')
        })
        .catch(err => {
          // 静默处理网络错误
          if (err.errMsg && (err.errMsg.includes('timeout') || err.errMsg.includes('request:fail'))) {
            console.log('网络不可用，播放进度已保存到本地')
          } else {
            console.warn('保存播放进度失败:', err.message)
          }
        })
    }
  },

  // 视频播放结束
  onVideoEnded(e) {
    console.log('视频播放结束事件触发:', e)
    console.log('当前课程:', this.data.course.title)
    console.log('当前章节:', this.data.currentChapter)
    
    // 停止自动保存
    if (this.playRecordManager) {
      this.playRecordManager.stop(this.data.currentProgress)
    }
    
    // 启动AI分析
    console.log('准备启动AI分析...')
    this.startAIAnalysis()
  },

  // 视频时间更新
  onVideoTimeUpdate(e) {
    const currentTime = e.detail.currentTime // 当前播放时间（秒）
    this.setData({
      currentProgress: Math.floor(currentTime)
    })
  },

  // 视频错误事件
  onVideoError(e) {
    console.error('视频播放错误:', e.detail)
    console.error('当前视频URL:', this.data.course.videoUrl)
    
    // 停止自动保存
    if (this.playRecordManager) {
      this.playRecordManager.stop()
    }
    
    // 如果视频URL是本地路径，提示用户
    if (this.data.course.videoUrl && 
        (this.data.course.videoUrl.includes('C:\\') || this.data.course.videoUrl.includes('D:\\'))) {
      wx.showModal({
        title: '视频播放提示',
        content: '当前视频为本地文件，小程序无法播放。已为您切换到示例视频。',
        showCancel: false,
        confirmText: '知道了'
      })
    } else {
      // 网络错误处理
      this.handleVideoNetworkError()
    }
  },

  // 处理视频网络错误
  handleVideoNetworkError() {
    wx.showModal({
      title: '视频加载失败',
      content: '网络连接不稳定，请检查网络后重试',
      showCancel: true,
      cancelText: '稍后重试',
      confirmText: '重新加载',
      success: (res) => {
        if (res.confirm) {
          this.reloadVideo()
        }
      }
    })
  },

  // 重新加载视频
  reloadVideo() {
    const videoContext = wx.createVideoContext('courseVideo', this)
    if (videoContext) {
      // 重新设置视频源，添加时间戳避免缓存
      const originalUrl = this.data.course.videoUrl
      const separator = originalUrl.includes('?') ? '&' : '?'
      const newUrl = originalUrl + separator + 't=' + Date.now()
      
      this.setData({
        'course.videoUrl': newUrl
      })
      
      // 延迟一点时间后重新播放
      setTimeout(() => {
        videoContext.play()
      }, 500)
      
      wx.showToast({
        title: '正在重新加载...',
        icon: 'loading',
        duration: 1000
      })
    }
  },

  onUnload() {
    // 页面卸载时停止自动保存
    if (this.playRecordManager) {
      this.playRecordManager.stop(this.data.currentProgress)
    }
  },

  onHide() {
    // 页面隐藏时暂停视频并保存进度
    if (this.videoContext) {
      this.videoContext.pause()
    }
    
    if (this.playRecordManager && this.data.currentProgress > 0) {
      this.playRecordManager.saveNow(this.data.currentProgress)
    }
  },

  // 视频开始加载
  onVideoLoadStart(e) {
    console.log('视频开始加载')
  },

  // 视频数据加载完成
  onVideoLoadedData(e) {
    console.log('视频数据加载完成')
  },

  // 处理poster URL - 不显示封面
  getPosterUrl(cover) {
    // 始终返回空字符串，不显示封面
    return ''
  },

  // 处理头像URL
  getAvatarUrl(avatar) {
    if (!avatar) {
      return 'https://images.unsplash.com/photo-1612349317150-e413f6a5b16d?w=200&h=200&fit=crop&crop=face'
    }
    
    // 如果是无效的URL，使用默认头像
    if (avatar.includes('lecturer-avatar.com') || avatar.includes('org-logo.com')) {
      return 'https://images.unsplash.com/photo-1612349317150-e413f6a5b16d?w=200&h=200&fit=crop&crop=face'
    }
    
    // 如果是有效的网络地址，直接使用
    if (avatar.startsWith('http') && !avatar.includes('lecturer-avatar.com') && !avatar.includes('org-logo.com')) {
      return avatar
    }
    
    // 其他情况使用默认头像
    return 'https://images.unsplash.com/photo-1612349317150-e413f6a5b16d?w=200&h=200&fit=crop&crop=face'
  },

  // 处理视频URL
  getVideoUrl(videoUrl) {
    if (!videoUrl) {
      return ''
    }
    
    // 如果是本地文件路径（Windows路径），使用示例视频
    if (videoUrl.includes('C:\\') || videoUrl.includes('D:\\') || videoUrl.includes('E:\\') || 
        videoUrl.includes('F:\\') || videoUrl.includes('G:\\') || videoUrl.includes('H:\\')) {
      return 'https://sample-videos.com/zip/10/mp4/SampleVideo_1280x720_1mb.mp4'
    }
    
    // 如果是网络地址，直接使用
    if (videoUrl.startsWith('http')) {
      return videoUrl
    }
    
    // 其他情况使用示例视频
    return 'https://sample-videos.com/zip/10/mp4/SampleVideo_1280x720_1mb.mp4'
  },

  /**
   * 显示AI分析选项
   */
  showAIAnalysisOptions() {
    console.log('显示AI分析选项')
    this.setData({
      showAIOptions: true,
      selectedAnalysisType: null
    })
  },

  /**
   * 隐藏AI分析选项
   */
  hideAIOptions() {
    this.setData({
      showAIOptions: false,
      selectedAnalysisType: null
    })
  },

  /**
   * 选择分析类型
   */
  selectAnalysisType(e) {
    const type = e.currentTarget.dataset.type
    console.log('选择分析类型:', type)
    this.setData({
      selectedAnalysisType: type
    })
  },

  /**
   * 启动AI分析
   */
  startAIAnalysis() {
    if (!this.data.selectedAnalysisType) {
      wx.showToast({
        title: '请选择分析类型',
        icon: 'none'
      })
      return
    }

    console.log('启动AI分析...', '分析类型:', this.data.selectedAnalysisType)
    
    // 关闭选项弹窗
    this.setData({
      showAIOptions: false,
      isAIAnalyzing: true,
      showAIAnalysis: true
    })
    
    // 显示AI分析提示
    const analysisTypeNames = {
      'summary': '重点总结',
      'comprehensive': '综合分析',
      'action': '动作规范度分析'
    }
    
    wx.showToast({
      title: `AI正在${analysisTypeNames[this.data.selectedAnalysisType]}...`,
      icon: 'loading',
      duration: 2000
    })
    
    // 模拟AI分析过程
    setTimeout(() => {
      console.log('开始生成AI分析结果...')
      this.generateAIAnalysis()
    }, 2000)
  },

  /**
   * 生成AI分析结果
   */
  generateAIAnalysis() {
    console.log('生成AI分析结果...', '分析类型:', this.data.selectedAnalysisType)
    const course = this.data.course
    const currentChapter = this.data.chapters.find(chapter => chapter.id === this.data.currentChapter)
    
    console.log('课程信息:', course)
    console.log('当前章节:', currentChapter)
    
    // 根据分析类型生成不同的AI分析
    let analysisData = this.getAIAnalysisByType(this.data.selectedAnalysisType, course, currentChapter)
    
    console.log('生成的AI分析数据:', analysisData)
    
    this.setData({
      aiAnalysisData: analysisData,
      isAIAnalyzing: false
    })
    
    console.log('AI分析完成，最终状态:', {
      showAIAnalysis: this.data.showAIAnalysis,
      isAIAnalyzing: this.data.isAIAnalyzing,
      aiAnalysisData: this.data.aiAnalysisData
    })
  },

  /**
   * 根据分析类型获取AI分析
   */
  getAIAnalysisByType(analysisType, course, chapter) {
    const courseTitle = course.title || ''
    const chapterTitle = chapter ? chapter.title : ''
    
    switch (analysisType) {
      case 'summary':
        return this.getSummaryAnalysis(courseTitle, chapterTitle)
      case 'comprehensive':
        return this.getComprehensiveAnalysis(courseTitle, chapterTitle)
      case 'action':
        return this.getActionAnalysis(courseTitle, chapterTitle)
      default:
        return this.getComprehensiveAnalysis(courseTitle, chapterTitle)
    }
  },

  /**
   * 重点总结分析
   */
  getSummaryAnalysis(courseTitle, chapterTitle) {
    return {
      type: 'summary',
      title: '重点总结',
      keyPoints: [
        '掌握核心概念和基本原理',
        '理解关键操作步骤和流程',
        '熟悉重要知识点和技巧',
        '了解常见问题和解决方案'
      ],
      highlights: [
        '重点内容1：基础理论知识的掌握',
        '重点内容2：实践操作技能的培养',
        '重点内容3：临床应用能力的提升',
        '重点内容4：安全操作规范的遵循'
      ]
    }
  },



  /**
   * 动作规范度分析
   */
  getActionAnalysis(courseTitle, chapterTitle) {
    // 模拟计算机视觉分析结果
    const actionScore = Math.floor(Math.random() * 30) + 70 // 70-100分
    let scoreLevel = ''
    
    if (actionScore >= 90) {
      scoreLevel = '优秀'
    } else if (actionScore >= 80) {
      scoreLevel = '良好'
    } else if (actionScore >= 70) {
      scoreLevel = '合格'
    } else {
      scoreLevel = '需改进'
    }
    
    return {
      type: 'action',
      title: '动作规范度分析',
      actionScore: actionScore,
      scoreLevel: scoreLevel,
      speedAnalysis: [
        '推拿速度：2.5次/秒，符合标准范围（2-3次/秒）',
        '节奏控制：稳定均匀，无明显加速或减速',
        '动作连贯性：各动作间过渡自然流畅',
        '建议：可适当增加节奏变化，提升手法层次感'
      ],
      forceAnalysis: [
        '力度控制：适中偏重，符合推拿要求',
        '压力分布：均匀，无局部过重现象',
        '渗透力：良好，能有效作用于深层组织',
        '建议：注意力度调节，避免长时间过重操作'
      ],
      angleAnalysis: [
        '手指角度：45-60度，符合人体工程学',
        '手腕角度：保持自然弯曲，避免过度伸展',
        '身体角度：与患者保持适当距离和角度',
        '建议：注意保持正确的操作姿势，减少疲劳'
      ],
      improvements: [
        '加强手指灵活度训练，提升精细操作能力',
        '练习力度渐进技巧，避免突然用力',
        '注意呼吸配合，保持操作节奏稳定',
        '定期进行手法练习，巩固肌肉记忆',
        '学习不同体位的适应技巧，提升适应性'
      ]
    }
  },

  /**
   * 综合分析
   */
  getComprehensiveAnalysis(courseTitle, chapterTitle) {
    return {
      type: 'comprehensive',
      title: '综合分析',
      benefits: [
        '促进血液循环，改善局部血液循环',
        '缓解肌肉紧张和疼痛',
        '增强关节灵活性和活动度',
        '调节神经系统，缓解压力',
        '提高免疫力，增强体质'
      ],
      precautions: [
        '皮肤有破损、炎症时不宜操作',
        '孕妇、心脏病患者需谨慎操作',
        '力度要适中，避免过度用力',
        '操作时间不宜过长，注意休息'
      ],
      tips: [
        '学习前先了解基础理论知识',
        '多练习基本手法和技巧',
        '注意观察和总结操作经验',
        '定期复习和巩固学习内容'
      ]
    }
  },

  /**
   * 根据课程类型获取AI分析（保留原方法）
   */
  getAIAnalysisByCourseType(course, chapter) {
    const courseTitle = course.title || ''
    const chapterTitle = chapter ? chapter.title : ''
    
    // 推拿相关课程
    if (courseTitle.includes('推拿') || chapterTitle.includes('推拿')) {
      return {
        title: '推拿技法AI分析',
        benefits: [
          '促进血液循环，改善局部血液循环',
          '缓解肌肉紧张和疼痛',
          '增强关节灵活性和活动度',
          '调节神经系统，缓解压力',
          '提高免疫力，增强体质'
        ],
        precautions: [
          '皮肤有破损、炎症时不宜推拿',
          '孕妇、心脏病患者需谨慎操作',
          '力度要适中，避免过度用力',
          '推拿后注意保暖，避免受凉',
          '饭后1小时内不宜进行推拿'
        ],
        tips: [
          '推拿前先了解患者身体状况',
          '手法要轻柔，循序渐进',
          '注意观察患者反应，及时调整',
          '推拿后适当休息，多喝水'
        ]
      }
    }
    
    // 艾灸相关课程
    if (courseTitle.includes('艾灸') || chapterTitle.includes('艾灸')) {
      return {
        title: '艾灸疗法AI分析',
        benefits: [
          '温通经络，散寒除湿',
          '调节气血，平衡阴阳',
          '增强免疫力，预防疾病',
          '缓解疼痛，改善睡眠',
          '美容养颜，延缓衰老'
        ],
        precautions: [
          '孕妇、儿童、体弱者慎用',
          '皮肤过敏者不宜艾灸',
          '艾灸时注意防火安全',
          '艾灸后避免立即洗澡',
          '空腹或过饱时不宜艾灸'
        ],
        tips: [
          '选择优质艾条，注意质量',
          '艾灸时间不宜过长',
          '艾灸后多喝温水',
          '保持室内通风'
        ]
      }
    }
    
    // 穴位相关课程
    if (courseTitle.includes('穴位') || chapterTitle.includes('穴位')) {
      return {
        title: '穴位疗法AI分析',
        benefits: [
          '精准刺激，效果显著',
          '调节脏腑功能',
          '缓解各种疼痛症状',
          '提高身体自愈能力',
          '无副作用，安全可靠'
        ],
        precautions: [
          '找准穴位位置，避免误按',
          '力度适中，不可过重',
          '孕妇某些穴位禁用',
          '皮肤破损处不宜按压',
          '饭后不宜立即按压'
        ],
        tips: [
          '学习正确的取穴方法',
          '按压时保持心情平静',
          '坚持长期练习',
          '结合其他疗法效果更佳'
        ]
      }
    }
    
    // 默认分析
    return {
      title: '中医技法AI分析',
      benefits: [
        '调节身体阴阳平衡',
        '促进气血运行',
        '增强体质，提高免疫力',
        '缓解疲劳，改善睡眠',
        '预防疾病，保健养生'
      ],
      precautions: [
        '根据个人体质选择合适方法',
        '操作时注意安全',
        '有疾病时请咨询专业医师',
        '坚持适度原则',
        '注意饮食和生活习惯'
      ],
      tips: [
        '学习正确的方法和技巧',
        '循序渐进，持之以恒',
        '结合个人情况调整',
        '定期评估效果'
      ]
    }
  },

  /**
   * 关闭AI分析
   */
  closeAIAnalysis() {
    this.setData({
      showAIAnalysis: false,
      aiAnalysisData: null,
      selectedAnalysisType: null
    })
  },

  /**
   * 初始化小圆球位置
   */
  initBallPosition() {
    // 获取系统信息
    const systemInfo = wx.getSystemInfoSync()
    const screenWidth = systemInfo.windowWidth
    const screenHeight = systemInfo.windowHeight
    
    // 设置初始位置为屏幕右下角
    const ballSize = 60 // 小圆球大小
    const margin = 20 // 边距
    
    this.setData({
      ballPosition: {
        x: screenWidth - ballSize - margin,
        y: screenHeight - ballSize - margin - 100 // 减去导航栏高度
      }
    })
  },

  /**
   * 小圆球触摸开始
   */
  onBallTouchStart(e) {
    const touch = e.touches[0]
    this.setData({
      ballTouchStart: {
        x: touch.clientX,
        y: touch.clientY
      },
      isDragging: false
    })
  },

  /**
   * 小圆球触摸移动
   */
  onBallTouchMove(e) {
    const touch = e.touches[0]
    const deltaX = touch.clientX - this.data.ballTouchStart.x
    const deltaY = touch.clientY - this.data.ballTouchStart.y
    
    // 如果移动距离超过阈值，开始拖拽
    if (Math.abs(deltaX) > 5 || Math.abs(deltaY) > 5) {
      this.setData({ isDragging: true })
    }
    
    if (this.data.isDragging) {
      // 获取系统信息
      const systemInfo = wx.getSystemInfoSync()
      const screenWidth = systemInfo.windowWidth
      const screenHeight = systemInfo.windowHeight
      const ballSize = 60
      
      // 计算新位置
      let newX = this.data.ballPosition.x + deltaX
      let newY = this.data.ballPosition.y + deltaY
      
      // 边界检测
      newX = Math.max(0, Math.min(newX, screenWidth - ballSize))
      newY = Math.max(0, Math.min(newY, screenHeight - ballSize - 100))
      
      this.setData({
        ballPosition: {
          x: newX,
          y: newY
        },
        ballTouchStart: {
          x: touch.clientX,
          y: touch.clientY
        }
      })
    }
  },

  /**
   * 小圆球触摸结束
   */
  onBallTouchEnd(e) {
    // 如果不是拖拽，则触发点击事件
    if (!this.data.isDragging) {
      this.showAIAnalysisOptions()
    }
    
    this.setData({ isDragging: false })
  },

  /**
   * 重新分析
   */
  reAnalyze() {
    this.startAIAnalysis()
  },

  /**
   * 同步离线播放记录
   */
  syncOfflineRecords() {
    const userId = this.data.userId
    if (userId) {
      playRecordUtil.syncOfflineRecords(userId)
        .then(() => {
          console.log('离线播放记录同步完成')
        })
        .catch(err => {
          console.log('离线播放记录同步失败，将在网络恢复时重试')
        })
    }
  },

  /**
   * 设置网络状态监听
   */
  setupNetworkMonitoring() {
    const userId = this.data.userId
    if (!userId) return

    // 检查networkMonitor是否存在
    if (!playRecordUtil.networkMonitor) {
      console.warn('networkMonitor 不可用，跳过网络状态监听设置')
      return
    }

    // 添加网络状态监听器
    try {
      playRecordUtil.networkMonitor.addListener((event) => {
        console.log('网络状态事件:', event)
        
        if (event === 'networkRestored') {
          // 网络恢复时，尝试同步离线记录
          console.log('网络已恢复，开始同步离线记录')
          this.syncOfflineRecords()
          
          wx.showToast({
            title: '网络已恢复',
            icon: 'success',
            duration: 1500
          })
        } else if (event === 'networkLost') {
          // 网络断开时，提示用户
          wx.showToast({
            title: '网络连接已断开',
            icon: 'none',
            duration: 2000
          })
        }
      })
      console.log('网络状态监听器设置成功')
    } catch (error) {
      console.error('设置网络状态监听器失败:', error)
    }
  },

})